home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / umich / tex / texsrc.arc / TEX3.C < prev    next >
C/C++ Source or Header  |  1988-09-14  |  44KB  |  2,018 lines
  1. overlay "tex3"
  2. #define EXTERN extern
  3. #include "texd.h"
  4.  
  5. scancharnum () { r_scancharnum 
  6.   scanint () ; 
  7.   if ( ( curval < 0 ) || ( curval > 255 ) ) 
  8.   {
  9.     {
  10.       if ( interaction == 3 ) 
  11.       wakeuptermin () ; 
  12.       printnl ( 133 ) ; 
  13.       print ( 543 ) ; 
  14.     } 
  15.     {
  16.       helpptr = 2 ; 
  17.       helpline [ 1 ] = 550 ; 
  18.       helpline [ 0 ] = 545 ; 
  19.     } 
  20.     interror ( curval ) ; 
  21.     curval = 0 ; 
  22.   } 
  23. } 
  24. scanfifteenb () { r_scanfifteenb 
  25.   scanint () ; 
  26.   if ( ( curval < 0 ) || ( curval > 32767 ) ) 
  27.   {
  28.     {
  29.       if ( interaction == 3 ) 
  30.       wakeuptermin () ; 
  31.       printnl ( 133 ) ; 
  32.       print ( 551 ) ; 
  33.     } 
  34.     {
  35.       helpptr = 2 ; 
  36.       helpline [ 1 ] = 552 ; 
  37.       helpline [ 0 ] = 545 ; 
  38.     } 
  39.     interror ( curval ) ; 
  40.     curval = 0 ; 
  41.   } 
  42. } 
  43. scantwentyse () { r_scantwentyse 
  44.   scanint () ; 
  45.   if ( ( curval < 0 ) || ( curval > 134217727 ) ) 
  46.   {
  47.     {
  48.       if ( interaction == 3 ) 
  49.       wakeuptermin () ; 
  50.       printnl ( 133 ) ; 
  51.       print ( 553 ) ; 
  52.     } 
  53.     {
  54.       helpptr = 2 ; 
  55.       helpline [ 1 ] = 554 ; 
  56.       helpline [ 0 ] = 545 ; 
  57.     } 
  58.     interror ( curval ) ; 
  59.     curval = 0 ; 
  60.   } 
  61. } 
  62. scanfontiden () { r_scanfontiden 
  63.   internalfont f ; 
  64.   halfword m ; 
  65.   do { getxtoken () ; 
  66.   } while ( ! ( curcmd != 10 ) ) ; 
  67.   if ( curcmd == 87 ) 
  68.   f = eqtb [ 4578 ] .hh .v.RH ; 
  69.   else if ( curcmd == 86 ) 
  70.   f = curchr ; 
  71.   else if ( curcmd == 85 ) 
  72.   {
  73.     m = curchr ; 
  74.     scanfourbiti () ; 
  75.     f = eqtb [ m + curval ] .hh .v.RH ; 
  76.   } 
  77.   else { 
  78.     {
  79.       if ( interaction == 3 ) 
  80.       wakeuptermin () ; 
  81.       printnl ( 133 ) ; 
  82.       print ( 670 ) ; 
  83.     } 
  84.     {
  85.       helpptr = 2 ; 
  86.       helpline [ 1 ] = 671 ; 
  87.       helpline [ 0 ] = 672 ; 
  88.     } 
  89.     backerror () ; 
  90.     f = 0 ; 
  91.   } 
  92.   curval = f ; 
  93. } 
  94. zfindfontdime ( writing ) 
  95. boolean writing ; 
  96. {r_findfontdime 
  97.   internalfont f ; 
  98.   integer n ; 
  99.   scanint () ; 
  100.   n = curval ; 
  101.   scanfontiden () ; 
  102.   f = curval ; 
  103.   if ( n <= 0 ) 
  104.   curval = fmemptr ; 
  105.   else { 
  106.     if ( writing && ( n <= 4 ) && ( n >= 2 ) && ( fontglue [ f ] != 0 ) ) 
  107.     {
  108.       deletegluere ( fontglue [ f ] ) ; 
  109.       fontglue [ f ] = 0 ; 
  110.     } 
  111.     if ( n > fontparams [ f ] ) 
  112.     if ( f < fontptr ) 
  113.     curval = fmemptr ; 
  114.     else { 
  115.       do { if ( fmemptr == fontmemsize ) 
  116.     overflow ( 677 , fontmemsize ) ; 
  117.     fontinfo [ fmemptr ] .cint = 0 ; 
  118.     incr ( fmemptr ) ; 
  119.     incr ( fontparams [ f ] ) ; 
  120.       } while ( ! ( n == fontparams [ f ] ) ) ; 
  121.       curval = fmemptr - 1 ; 
  122.     } 
  123.     else curval = n + parambase [ f ] ; 
  124.   } 
  125.   if ( curval == fmemptr ) 
  126.   {
  127.     {
  128.       if ( interaction == 3 ) 
  129.       wakeuptermin () ; 
  130.       printnl ( 133 ) ; 
  131.       print ( 655 ) ; 
  132.     } 
  133.     printesc ( hash [ 3268 + f ] .v.RH ) ; 
  134.     print ( 673 ) ; 
  135.     printint ( fontparams [ f ] ) ; 
  136.     print ( 674 ) ; 
  137.     {
  138.       helpptr = 2 ; 
  139.       helpline [ 1 ] = 675 ; 
  140.       helpline [ 0 ] = 676 ; 
  141.     } 
  142.     error () ; 
  143.   } 
  144. } 
  145. zscansomethin ( level , negative ) 
  146. smallnumber level ; 
  147. boolean negative ; 
  148. {r_scansomethin 
  149.   halfword m ; 
  150.   integer p ; 
  151.   m = curchr ; 
  152.   switch ( curcmd ) 
  153.   {case 84 : 
  154.     {
  155.       scansevenbit () ; 
  156.       if ( m == 5139 ) 
  157.       {
  158.     curval = eqtb [ 5139 + curval ] .hh .v.RH ; 
  159.     curvallevel = 0 ; 
  160.       } 
  161.       else if ( m < 5139 ) 
  162.       {
  163.     curval = eqtb [ m + curval ] .hh .v.RH ; 
  164.     curvallevel = 0 ; 
  165.       } 
  166.       else { 
  167.     curval = eqtb [ m + curval ] .cint ; 
  168.     curvallevel = 0 ; 
  169.       } 
  170.     } 
  171.     break ; 
  172.   case 70 : 
  173.   case 71 : 
  174.   case 85 : 
  175.   case 86 : 
  176.   case 87 : 
  177.     if ( level != 5 ) 
  178.     {
  179.       {
  180.     if ( interaction == 3 ) 
  181.     wakeuptermin () ; 
  182.     printnl ( 133 ) ; 
  183.     print ( 522 ) ; 
  184.       } 
  185.       {
  186.     helpptr = 3 ; 
  187.     helpline [ 2 ] = 523 ; 
  188.     helpline [ 1 ] = 524 ; 
  189.     helpline [ 0 ] = 525 ; 
  190.       } 
  191.       backerror () ; 
  192.       {
  193.     curval = 0 ; 
  194.     curvallevel = 1 ; 
  195.       } 
  196.     } 
  197.     else if ( curcmd <= 71 ) 
  198.     {
  199.       if ( curcmd < 71 ) 
  200.       {
  201.     scaneightbit () ; 
  202.     m = 4066 + curval ; 
  203.       } 
  204.       {
  205.     curval = eqtb [ m ] .hh .v.RH ; 
  206.     curvallevel = 5 ; 
  207.       } 
  208.     } 
  209.     else { 
  210.       backinput () ; 
  211.       scanfontiden () ; 
  212.       {
  213.     curval = 3268 + curval ; 
  214.     curvallevel = 4 ; 
  215.       } 
  216.     } 
  217.     break ; 
  218.   case 72 : 
  219.     {
  220.       curval = eqtb [ m ] .cint ; 
  221.       curvallevel = 0 ; 
  222.     } 
  223.     break ; 
  224.   case 73 : 
  225.     {
  226.       curval = eqtb [ m ] .cint ; 
  227.       curvallevel = 1 ; 
  228.     } 
  229.     break ; 
  230.   case 74 : 
  231.     {
  232.       curval = eqtb [ m ] .hh .v.RH ; 
  233.       curvallevel = 2 ; 
  234.     } 
  235.     break ; 
  236.   case 75 : 
  237.     {
  238.       curval = eqtb [ m ] .hh .v.RH ; 
  239.       curvallevel = 3 ; 
  240.     } 
  241.     break ; 
  242.   case 78 : 
  243.     if ( abs ( curlist .modefield ) != m ) 
  244.     {
  245.       {
  246.     if ( interaction == 3 ) 
  247.     wakeuptermin () ; 
  248.     printnl ( 133 ) ; 
  249.     print ( 536 ) ; 
  250.       } 
  251.       printcmdchr ( 78 , m ) ; 
  252.       {
  253.     helpptr = 4 ; 
  254.     helpline [ 3 ] = 537 ; 
  255.     helpline [ 2 ] = 538 ; 
  256.     helpline [ 1 ] = 539 ; 
  257.     helpline [ 0 ] = 540 ; 
  258.       } 
  259.       error () ; 
  260.       if ( level != 5 ) 
  261.       {
  262.     curval = 0 ; 
  263.     curvallevel = 1 ; 
  264.       } 
  265.       else { 
  266.     curval = 0 ; 
  267.     curvallevel = 0 ; 
  268.       } 
  269.     } 
  270.     else { 
  271.       curval = curlist .auxfield ; 
  272.       if ( m == 1 ) 
  273.       curvallevel = 1 ; 
  274.       else curvallevel = 0 ; 
  275.     } 
  276.     break ; 
  277.   case 79 : 
  278.     {
  279.       nest [ nestptr ] = curlist ; 
  280.       p = nestptr ; 
  281.       while ( abs ( nest [ p ] .modefield ) != 1 ) decr ( p ) ; 
  282.       {
  283.     curval = nest [ p ] .pgfield ; 
  284.     curvallevel = 0 ; 
  285.       } 
  286.     } 
  287.     break ; 
  288.   case 81 : 
  289.     {
  290.       if ( m == 0 ) 
  291.       curval = deadcycles ; 
  292.       else curval = insertpenalt ; 
  293.       curvallevel = 0 ; 
  294.     } 
  295.     break ; 
  296.   case 80 : 
  297.     {
  298.       if ( pagecontents == 0 ) 
  299.       if ( m == 0 ) 
  300.       curval = 1073741823 ; 
  301.       else curval = 0 ; 
  302.       else curval = pagesofar [ m ] ; 
  303.       curvallevel = 1 ; 
  304.     } 
  305.     break ; 
  306.   case 83 : 
  307.     {
  308.       if ( eqtb [ 4056 ] .hh .v.RH == 0 ) 
  309.       curval = 0 ; 
  310.       else curval = mem [(long) eqtb [ 4056 ] .hh .v.RH ] .hh .v.LH ; 
  311.       curvallevel = 0 ; 
  312.     } 
  313.     break ; 
  314.   case 82 : 
  315.     {
  316.       scaneightbit () ; 
  317.       if ( eqtb [ 4322 + curval ] .hh .v.RH == 0 ) 
  318.       curval = 0 ; 
  319.       else curval = mem [(long) eqtb [ 4322 + curval ] .hh .v.RH + m ] .cint ; 
  320.       curvallevel = 1 ; 
  321.     } 
  322.     break ; 
  323.   case 67 : 
  324.   case 68 : 
  325.     {
  326.       curval = curchr ; 
  327.       curvallevel = 0 ; 
  328.     } 
  329.     break ; 
  330.   case 76 : 
  331.     {
  332.       findfontdime ( false ) ; 
  333.       fontinfo [ fmemptr ] .cint = 0 ; 
  334.       {
  335.     curval = fontinfo [ curval ] .cint ; 
  336.     curvallevel = 1 ; 
  337.       } 
  338.     } 
  339.     break ; 
  340.   case 77 : 
  341.     {
  342.       scanfontiden () ; 
  343.       if ( m == 0 ) 
  344.       {
  345.     curval = hyphenchar [ curval ] ; 
  346.     curvallevel = 0 ; 
  347.       } 
  348.       else { 
  349.     curval = skewchar [ curval ] ; 
  350.     curvallevel = 0 ; 
  351.       } 
  352.     } 
  353.     break ; 
  354.   case 88 : 
  355.     {
  356.       scaneightbit () ; 
  357.       switch ( m ) 
  358.       {case 0 : 
  359.     curval = eqtb [ 5317 + curval ] .cint ; 
  360.     break ; 
  361.       case 1 : 
  362.     curval = eqtb [ 5721 + curval ] .cint ; 
  363.     break ; 
  364.       case 2 : 
  365.     curval = eqtb [ 3544 + curval ] .hh .v.RH ; 
  366.     break ; 
  367.       case 3 : 
  368.     curval = eqtb [ 3800 + curval ] .hh .v.RH ; 
  369.     break ; 
  370.       } 
  371.       curvallevel = m ; 
  372.     } 
  373.     break ; 
  374.   case 69 : 
  375.     {
  376.       if ( curchr == 2 ) 
  377.       curval = 0 ; 
  378.       else curval = 0 ; 
  379.       curvallevel = curchr ; 
  380.       if ( ! ( curlist .tailfield >= himemmin ) && ( curlist .modefield != 0 ) 
  381.       ) 
  382.       switch ( curchr ) 
  383.       {case 0 : 
  384.     if ( mem [(long) curlist .tailfield ] .hh.b0 == 12 ) 
  385.     curval = mem [(long) curlist .tailfield + 1 ] .cint ; 
  386.     break ; 
  387.       case 1 : 
  388.     if ( mem [(long) curlist .tailfield ] .hh.b0 == 11 ) 
  389.     curval = mem [(long) curlist .tailfield + 1 ] .cint ; 
  390.     break ; 
  391.       case 2 : 
  392.     if ( mem [(long) curlist .tailfield ] .hh.b0 == 10 ) 
  393.     {
  394.       curval = mem [(long) curlist .tailfield + 1 ] .